﻿<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Introduction</title>
</head>
<body>
    <h2>
        Introduction</h2>
    <p>
        The Genesis Smart Client Framework was developed by Blue Marble, a South African
        software development house. The framework was developed as the means of distributing
        an application to a large wide-spread audience over the internet.</p>
    <p>
        By providing a Dynamic Application Workspace the framework allowed the development
        team to focus on developing task specific modules, while the framework dealt with
        keeping client software up to date with the latest version of the modules, and provided
        users access to modules they were allowed to work with.</p>
    <p>
        This article is a step-by-step guide for writing a Twitter client application. It
        continues where the <a title="Getting Started" href="GenesisSCFGettingStarted.aspx"
            target="_blank">Getting Started</a> article left off. If you have not read this
        article yet, please do so now.</p>
    <p>
        In the previous article you were introduced to the steps required to get the latest
        build of the Genesis Smart Client Framework running on your computer. You also learnt
        how to get the Template Application configured and runnning. In this article you
        will learn to enhance the Template Application to include a simple Twitter client.
        This client will use an existing C# Twitter library (LinqToTwitter, see below).</p>
    <h2>
        Why Twitter?</h2>
    <p>
        I decided to use Twitter as a generic application type to demonstrate the features
        of the Genesis Smart Client Framework. Using Twitter you will not be distracted
        by other unrelated features and concepts. Everybody knows that you can only send
        a status update to twitter, and read your twitter feed. We will ignore advanced
        features such as retweeting, user profiles etc.</p>
    <p>
        I have never written a Twitter client before, so this will also be a first for me
        to develop using the Twitter API. Since this is my first attempt at a Twitter client,
        I did some research, and decided to settle for LINQToTwitter (<a title="LinqToTwitter"
            href="http://linqtotwitter.codeplex.com/" target="_blank">http://linqtotwitter.codeplex.com/</a>)
        as the preferred library to use.</p>
    <h2>
        Preparing the project</h2>
    <p>
        The LinqToTwitter library supports OpenAuth (OAuth) and we will use this as the
        default authentication mechanism. This will cause Twitter to prompt the user via
        an Internet browser if he/she is using the program. The user will be given a Verification
        PIN which we capture from the application.</p>
    <p>
        Register an account with Twitter at <a title="New Twitter Apps" href="http://dev.twitter.com/apps/new"
            target="_blank">http://dev.twitter.com/apps/new</a> to get your Consumer Key
        and Consumer Secret. These values are used to uniquely identify your application
        when transacting with Twitter. You will need to enter these values in the correct 
        places in the Constants file below.</p>
    <p>
        I have created a new static class called Constants in the Genesis.Application project.
        This class contains some constant string values, including OAuthConsumerKey, OAuthConsumerSecret,
        the Request Token URL, Access Token URL and the Authorize URL. You HAVE to update
        these values with the values that you get from the registration of your application
        with Twitter on the URL above.</p>
    <img alt="Constants" src="GenesisSCFTwitter/0001.png" complete="true" complete="true" />
    <pre lang="c#">namespace Genesis.Application
{
    public static class Constants
    {
        public const string OAuthConsumerKey = &quot;YOURCONSUMERKEY&quot;;
        public const string OAuthConsumerSecret = &quot;YOURCONSUMERSECRET&quot;;
        public const string OAuthRequestTokenURL = &quot;https://api.twitter.com/oauth/request_token&quot;;
        public const string OAuthAccessTokenURL = &quot;https://api.twitter.com/oauth/access_token&quot;;
        public const string OAuthAuthorizeURL = &quot;https://api.twitter.com/oauth/authorize&quot;;
    }
}</pre>
    <p>
        Next you have to include a reference to the LinqToTwitter library in the Genesis.Application
        project. You can find this file in the download of the LinqToTwitter library from
        CodePlex. In order to use this library you have to change the &lt;startup&gt; tag
        in the app.config file for the <em>BlueMarble.Genesis.Client</em> project to &lt;startup
        useLegacyV2RuntimeActivationPolicy=&quot;true&quot;&gt;. I have included a Microsoft.NET
        4.0 build of this library in the $/Stable/Stable Assemblies folder in the online
        source control at CodePlex.</p>
    <img alt="References" src="GenesisSCFTwitter/0002.png" complete="true" complete="true" />
    <p>
        To initialize the LinqToTwitter library we need to create a GlobalDataSetFunctionsInitializer
        implementation in the Genesis.Application project. The GlobalDataSetFunctionsInitializer
        is used by Genesis Hosted Applications that require initialization code to be executed
        during the startup of the application. The Client Application will identify any
        classes that implement the <em>Genesis.Common.Interfaces.IGlobalDataSetFunctionsInitializer</em>
        interface and automatically execute them before displaying the main form. In the
        GlobalDataSetFunctionsInitializer we will create a new ITwitterAuthorization and
        set the ConsumerKey and ConsumerSecret using the string constant values that we
        created.</p>
    <pre lang="c#">public void Initialize(Common.Classes.GlobalDataSetFunctions GlobalDataSetFunctions)
{
    Globals.auth = new DesktopOAuthAuthorization();

    (Globals.auth as DesktopOAuthAuthorization).ConsumerKey = Genesis.Application.Constants.OAuthConsumerKey;
    (Globals.auth as DesktopOAuthAuthorization).ConsumerSecret = Genesis.Application.Constants.OAuthConsumerSecret;

    Globals.auth.UseCompression = false;
    Globals.auth.UserAgent = &quot;Genesis Template Application&quot;;
}

private string VerifierString()
{
    return Genesis.Application.Forms.Verifier.GetVerificationPin();
}</pre>
    <p>
        I have also created a Globals.cs class to contain the ITwitterAuthorization in a
        static class. This class will ensure that the LinqToTwitterWrapper is in shared
        memory. Not all applications will use global static classes, however I believe that
        dealing with the Twitter API it would be best to keep performance and resources
        in mind. I have also created a LinqToTwitterWrapper.cs which exposes static methods
        to deal with the Globals class. The wrapper acts as the Controller in a typical
        Model-View-Controller configuration.</p>
    <pre lang="c#">public static class Globals
{
    public static ITwitterAuthorization auth;
}</pre>
    <pre lang="c#">public static class LinqToTwitterWrapper
    {
        public static TwitterContext twitterCtx = new TwitterContext(Globals.auth, &quot;https://api.twitter.com/1/&quot;, &quot;http://search.twitter.com/&quot;);

        public static void SignOn()
        {
            if (twitterCtx.AuthorizedClient is OAuthAuthorization)
            {
                InitializeOAuthConsumerStrings(twitterCtx);
            }

            try
            {
                Globals.auth.SignOn();
            }
            catch (OperationCanceledException)
            {
                return;
            }
        }

        private static void InitializeOAuthConsumerStrings(TwitterContext twitterCtx)
        {
            var oauth = (DesktopOAuthAuthorization)twitterCtx.AuthorizedClient;
            oauth.GetVerifier = () =&gt;
            {
                return Genesis.Application.Forms.Verifier.GetVerificationPin();
            };

            if (oauth.CachedCredentialsAvailable)
            {
                Console.WriteLine(&quot;Skipping OAuth authorization step because that has already been done.&quot;);
            }
        }
    }</pre>
    <p>
        Because of how this implementation of the Twitter API using LinqToTwitter and OAuth
        works, we will rely on Twitter to provide us with an OAuth authentication token.
        This will happen automatically because an Internet browser will open asking the
        user to log in, or to confirm that the application is allowed to access the Twitter
        API using the users' credentials. The Twitter site will then provide the user with
        a Verification PIN which needs to be provided to the application. The following
        screen is used to capture the Verification PIN from the user, and is displayed during
        the authentication process.</p>
    <img alt="References" src="GenesisSCFTwitter/0013.png" complete="true" complete="true" />
    <p>
        During the sample we will continue to add more code to the classes above. We are
        now ready to move on to the next step.</p>
    <h2>
        Creating a User Interface</h2>
    <p>
        In this section we will create a form to display Tweets and the command to show
        the form. The form is going to be very simple and straight forward by using a ListBox
        to show the individual tweets and a textbox to allow the user to send a Tweet.</p>
    <img alt="Tweetform" src="GenesisSCFTwitter/0003.png" complete="true" complete="true" />
    <p>
        In order to make the form usable through the Genesis Smart Client Framework, we
        have to change the default inherited class from Form to <em>Genesis.Client.Common.Classes.MdiChildBase</em>
        and also to include the <em>Genesis.Common.Interfaces.IMdiChild</em> interface.</p>
    <img alt="Tweetform" src="GenesisSCFTwitter/0004.png" complete="true" complete="true" />
    <pre lang="c#">public partial class TweetForm : Genesis.Client.Common.Classes.MdiChildBase, Genesis.Common.Interfaces.IMdiChild
{
    public TweetForm()
    {
        InitializeComponent();</pre>
    <p>
        Next you have to create the Command to allow Genesis to load the form in the User
        Interface. This is a class that inherits from <em>Genesis.Common.Classes.CommandBase</em>
        and implements the <em>Genesis.Common.Interfaces.ICommand</em> interface. This class
        has an Execute method which executes the code it contains. Genesis will ensure that
        the user has the correct security rights before it allows execution of this code.</p>
    <pre lang="c#">[Genesis.Common.Attributes.CommandCode(&quot;Genesis.Application.Commands.ShowTweetForm&quot;)]
[Genesis.Common.Attributes.CommandDescription(&quot;This command shows the tweet form&quot;)]
[Genesis.Common.Attributes.CommandName(&quot;Twitter Form&quot;)]
public class ShowTweetForm : Genesis.Common.Classes.CommandBase, Genesis.Common.Interfaces.ICommand
{
    #region ICommand Members

    void Genesis.Common.Interfaces.ICommand.Execute()
    {
        Genesis.Application.Forms.TweetForm tweetForm = new Genesis.Application.Forms.TweetForm();

        tweetForm.Host = base.host;

        base.host.CreateWindow(tweetForm);
    }

    #endregion
}</pre>
    <p>
        The code above is simple and self-descriptive, starting with the Attributes applied
        to the ShowTweetForm class:</p>
    <ul>
        <li><strong>CommandCode</strong> - The command code is a unique reference to this Command
            and is used by the Genesis Smart Client Framework to identify the correct class
            to execute. It is also used by the Update.aspx page in the Genesis.FileHost project
            to identify new Commands and to update existing Commands. For code maintenance reasons,
            it is simpler to keep the command code the same as the full namespace and classname.
            It is not limited to being the same as the full namespace and classname. </li>
        <li><strong>CommandDescription</strong> - The command description contains a description
            of the command. </li>
        <li><strong>CommandName</strong> - The command name contains an easy name for the command.
        </li>
    </ul>
    <p>
        Looking at the class you will see that it only contains one method called Execute
        and that it does not require any parameters. In this implementation we see three
        lines of code. The first line creates a new copy of the <em>TweetForm</em>. The
        second line sets the <em>Host</em> property on the form. This property is available
        because of the interface that we implemented on the form. By passing the <em>Host</em>
        to the form, we are enabling the form to integrate directly with the main form of
        the BlueMarble.Genesis.Client application. The main form implements the <em>global::Genesis.Common.Interfaces.IHost</em>.</p>
    <p>
        The third line of code accesses the <em>Host</em> property on the Command and instructs
        the main form to create a new window by calling the <em>CreateWindow</em> method.</p>
    <p>
        We have written all the code we need to for now, in the next step we will configure
        the Genesis Smart Client Framework to identify the new Command and to set the security.</p>
    <h2>
        Configuring Genesis</h2>
    <p>
        The first step to configuring the new Command is to change the current version number
        for the application and then to recompile the application. Change the <em>AssemblyVersion</em>
        and <em>AssemblyFileVersion</em> attributes in the <em>AssemblyInfo.cs</em> file
        to any other version number. The actual number is unimportant, Genesis never expects
        a version to be higher/lower than the existing entries in the database. Genesis
        will respond if the version number has changed in any way.
    </p>
    <p>
        I have set my version information to:</p>
    <pre lang="c#">[assembly: AssemblyVersion(&quot;1.0.1.1&quot;)]
[assembly: AssemblyFileVersion(&quot;1.0.1.1&quot;)]</pre>
    <p>
        Once you have done this, rebuild the project output and wait for the Update.ASPX
        page to complete its execution. Once you recompile the Update.aspx page should automatically
        open indicating that the project output has changed.</p>
    <img alt="UpdateOutput" src="GenesisSCFTwitter/0005.png" complete="true" complete="true" />
    <p>
        Once the update process has run, you will notice that Genesis has identified the
        new version number as <strong>1.0.1.1</strong> and that it also added a reference
        to the <em>Genesis.Application.Commands.ShowTweetForm</em> Command.</p>
    <p>
        You can now run the application and sign into the <em>Genesis Management System 2010</em>
        application.</p>
    <h3>
        Commands</h3>
    <p>
        Once you are signed into the <em>Genesis Management System 2010</em>, open the <em>Genesis
            Administration</em> menu and click on the <em>Commands</em> menu item. This
        will open the Commands screen. Look for the <em>Genesis.Application.Commands.ShowTweetForm</em>
        command and open its editor. Scroll down to the <em>Group Membership</em> section
        of the form and add the <em>Registered Users</em> and <em>Genesis Application Users</em>
        roles to this Command.</p>
    <img alt="CommandRoles" src="GenesisSCFTwitter/0006.png" complete="true" complete="true" />
    <p>
        This will enable users who are members of these roles to execute the Command. Next
        open the <em>Genesis Administration</em> menu and click on the <em>Item</em> menu
        item. We are going to create the menu item that will open this form. Create a new
        Bar Item by clicking on the <em>Create Bar Item</em> icon in the top right corner
        of the page.</p>
    <p>
        Enter the following information into the provided fields:</p>
    <ul>
        <li><strong>Bar Name</strong> - Tweets </li>
        <li><strong>Parent Bar Item</strong> - &lt;Root Item&gt; </li>
        <li><strong>Bar Item Type</strong> - Button Item </li>
        <li><strong>Ribbon Bar</strong> - Seperator 1 </li>
        <li><strong>Command</strong> - Twitter Form </li>
        <li><strong>Image</strong> - Select any image from the list, and enter <strong>16</strong>
            in the <em>Size</em> value. </li>
        <li><strong>Order</strong> - 200 </li>
    </ul>
    <h3>
        Files</h3>
    <p>
        This application is referencing the <strong>LinqToTwitter.DLL</strong> library.
        Because the Genesis Client Application downloads only the files configured per application
        in Genesis, we also have to add this library to the configuration to ensure that
        it exists on the client when the Client Application executes your Genesis Hosted
        Application. Open on the <em>Genesis Administration</em> menu and click on the <em>Files</em>
        menu item.</p>
    <p>
        Enter the following information into the provided fields:</p>
    <ul>
        <li><strong>File Name</strong> - LinqToTwitter.dll </li>
        <li><strong>Type</strong> - LinqToTwitter Library. </li>
        <li><strong>Description</strong> - LinqToTwitter library eases the use of the Twitter
            API. </li>
        <li><strong>Application</strong> - <em>My First Genesis Application</em>. </li>
        <li><strong>Order</strong> - 200. </li>
        <li><strong>Path</strong> - ..\..\Genesis Smart Framework\Genesis.Client.Host\bin\debug\
        </li>
        <li><strong>Url</strong> - http://localhost:1581/genesis.filehost/myapp/libraries/LinqToTwitter.dllx
        </li>
        <li><strong>Version</strong> - 1.0.0.0 </li>
    </ul>
    <p>
        The LinqToTwitter.DLL library has references to some other libraries (<em>also available
            in the LinqToTwitter download and in $/Stable/Stable Assemblies in the CodePlex
            online source control</em>) and these libraries have to be included in the list
        along with the LinqToTwitter.DLL. These files are:</p>
    <ul>
        <li>DotNetOpenAuth.dll </li>
        <li>System.Web.Mvc.dll </li>
        <li>log4net.dll </li>
        <li>Kerr.Credentials.dll </li>
    </ul>
    <p>
        You can now sign out of the <em>Genesis Management System 2010</em>. Update the
        version number Attributes in the Genesis.Application project and rerun your application.
        You should now see entries for each of the new files on the output from the Update.ASPX
        page in the Genesis.FileHost website.</p>
    <p>
        I have set my version information to:</p>
    <pre lang="c#">[assembly: AssemblyVersion(&quot;1.0.1.2&quot;)]
[assembly: AssemblyFileVersion(&quot;1.0.1.2&quot;)]</pre>
    <p>
        Once you have changed your version information you can rebuild the solution, and
        the files should now be visible in the output from the Update.ASPX page.</p>
    <img alt="File" src="GenesisSCFTwitter/0009.png" complete="true" complete="true" /><br />
    <img alt="File" src="GenesisSCFTwitter/0010.png" complete="true" complete="true" /><br />
    <img alt="File" src="GenesisSCFTwitter/0011.png" complete="true" complete="true" /><br />
    <p>
        <em>If you followed the steps detailed in the <a href="GenesisSCFGettingStarted.aspx">
            previous article</a> you should have an application called <strong>My First Genesis
                Application</strong></em></p>
    <p>
        Once you are signed into your own application you should notice a new menu item
        in the <em>My First Menu</em> menu called <em>Tweets</em>. This menu is visible
        because you added it to the configuration earlier, and because your user is a member
        of one or more of the groups that were added to the <em>Genesis.Application.Commands.ShowTweetForm</em>
        Command.</p>
    <img alt="Tweets" src="GenesisSCFTwitter/0007.png" complete="true" complete="true" />
    <p>
        Click on this menu to open the <em>Tweet Form</em>. The image below is slightly
        cropped, to the right of the image there is simply a 'Tweet!' button and then the
        end of the form. This form was added to the main form because the main form implements
        the <em>IHost</em> interface. This interface allows the Commands, and child windows
        to communicate with the main form to instruct it to open/close forms, update the
        status bar text, create/remove menu's and menu items.</p>
    <img alt="TweetForm" src="GenesisSCFTwitter/0008.png" complete="true" complete="true" />
    <p>
        We can now focus on adding functionality to the form since we have done everything
        that the Genesis Smart Client Framework requires. <strong>REMEMBER:</strong> Each
        time we want to debug and test new features or fixes we simply have to change the
        <strong>AssemblyVersion</strong> and <strong>AssemblyFileVersion</strong> attributes.</p>
    <h2>
        Making it Tweet</h2>
    <p>
        In this section we will link up the Tweet Form to the Twitter API via LinqToTwitter.
        You will write a Linq query to select all of the users' Tweets from his/her followers
        or themselves. You will also allow the user to update his/her status by sending
        a Tweet.</p>
    <p>
        The first step was to add a method to the LinqToTwitterWrapper class to expose the
        Twitter public feed to our application. This method selects all of the tweets whose
        type is either a Public tweet, or a tweet from Friends. It also sorts the tweets
        so that the newest always appears first in the list.</p>
    <pre lang="c#">public static LinqToTwitter.TwitterQueryable&lt;LinqToTwitter.Status&gt; GetPublicTweets()
{
    var tweets =
        from tweet in twitterCtx.Status
        where tweet.Type == (Globals.auth.CachedCredentialsAvailable ? StatusType.Friends : StatusType.Public)
        orderby tweet.CreatedAt ascending
        select tweet;

    return (LinqToTwitter.TwitterQueryable&lt;LinqToTwitter.Status&gt;)tweets;
}</pre>
    <p>
        The we are going to link up our Tweet Form to process this feed and to display the
        results in the List Box. Add a Timer control to the Tweet Form and set the <em>Interval</em>
        to 60000 (one minute). Next make sure that your code behind looks like this:</p>
    <pre lang="c#">public partial class TweetForm : Genesis.Client.Common.Classes.MdiChildBase, Genesis.Common.Interfaces.IMdiChild
{
    public TweetForm()
    {
        InitializeComponent();

        LinqToTwitterWrapper.SignOn();
    }

    private void tweemer_Tick(object sender, EventArgs e) 
    { 
        tweemer.Enabled = false;

        LinqToTwitter.TwitterQueryable &lt;linqtotwitter.status&gt; statusTweets = LinqToTwitterWrapper.GetPublicTweets();

        foreach (LinqToTwitter.Status status in statusTweets)
        {
            string tweet = string.Empty;

            tweet = string.Format(&quot;{0} said {1} - {2} ago&quot;,
                status.User.Name,
                status.Text,
                GetTweetTime(status));

            if (!tweets.Items.Contains(tweet))
                tweets.Items.Insert(0, tweet);
        }

        tweemer.Enabled = true;
    }

    private static string GetTweetTime(LinqToTwitter.Status status)
    {
        TimeSpan tweetTime = new TimeSpan(DateTime.Now.Ticks - status.CreatedAt.Ticks);

        string returnValue = string.Empty;

        if (tweetTime.TotalSeconds &lt; 60)
        {
            returnValue = string.Format(&quot;{0} seconds ago&quot;,
                tweetTime.TotalSeconds);
        }
        else if (tweetTime.TotalMinutes &lt; 60)
        {
            returnValue = string.Format(&quot;{0} minutes ago&quot;,
                tweetTime.TotalMinutes);
        }
        else if (tweetTime.TotalHours &lt; 24)
        {
            returnValue = string.Format(&quot;{0} hours ago&quot;,
                tweetTime.TotalHours);
        }
        else
        {
            returnValue = string.Format(&quot;{0} days ago&quot;,
                tweetTime.TotalDays);
        }

        return returnValue;
    }
}</pre>
    <p>
        You are now ready to run the application and access your tweets. Update the version
        number Attributes in the Genesis.Application project and rerun your application.
        You should now see entries for each of the new files on the output from the Update.ASPX
        page in the Genesis.FileHost website.</p>
    <p>
        I have set my version information to:</p>
    <pre lang="c#">[assembly: AssemblyVersion(&quot;1.0.1.3&quot;)]
[assembly: AssemblyFileVersion(&quot;1.0.1.3&quot;)]</pre>
    <h2>
        Tweeting</h2>
    <p>
        Run the application and log into <em>My First Genesis Application</em>. Open the
        <em>My First Menu</em> menu and click on the <em>Tweets</em> menu item. The first
        time that you do this, your Internet browser should open automatically to confirm
        if this application is allowed to access your tweets.</p>
    <img alt="Verification" src="GenesisSCFTwitter/0012.png" complete="true" complete="true" />
    <p>
        Click <strong>Allow</strong> to get the Verification PIN. You will need to copy
        this PIN so that you can provide it to the Twitter client for authentication.</p>
    <img alt="Verification" src="GenesisSCFTwitter/0014.png" complete="true" complete="true" />
    <p>
        Enter the Verification PIN into the space provided on the Verification PIN form
        in the application. This PIN will be provided to the OAuth provider and only has
        to be done once. The authentication token is cached until such a time as the user
        reboots his/her computer, or if the user is inactive for a sufficient amount of
        time.</p>
    <img alt="Verification" src="GenesisSCFTwitter/0015.png" complete="true" complete="true" />
    <p>
        Your tweets should now be visible in the list box as below. The format of the output
        in the listbox is &quot;{<strong>USER</strong>} said {<strong>TWEET</strong>} -
        {<strong>TIMESTAMP</strong>}&quot;. In the image below you will notice some highlighted
        areas indicating the USER, TWEET and TIMESTAMP fields.</p>
    <img alt="Tweets" src="GenesisSCFTwitter/0016.png" complete="true" complete="true" />
    <p>
        The next step will be to allow the user to send their Tweets. To do this, add the
        following code to the <em>tweetton</em> (thats the name of the 'Tweet!' button):</p>
    <pre lang="c#"> LinqToTwitterWrapper.UpdateStatus(tweetBox.Text);
tweetBox.Text = string.Empty;

tweemer_Tick(sender, e);</pre>
    <p>
        This code will use the LinqToTwitterWrapper to execute the UpdateStatus method,
        then it will clear the <em>tweetBox</em> (thats the name of the status textbox)
        and execute the <em>tweemer_Tick</em> event (<em>tweemer</em> is the name of the
        Twitter timer)</p>
    <p>
        Add the following code to the LinqToTwitterWrapper:</p>
    <pre lang="c#">public static void UpdateStatus(string Tweet)
{
    twitterCtx.UpdateStatus(Tweet);
}</pre>
    <p>
        This code will execute the UpdateStatus method on the TwitterContext static field.
        The Tweet is passed in as a parameter.</p>
    <p>
        Update the version number Attributes in the Genesis.Application project and rerun
        your application. You should now see entries for each of the new files on the output
        from the Update.ASPX page in the Genesis.FileHost website.</p>
    <p>
        I have set my version information to:</p>
    <pre lang="c#">[assembly: AssemblyVersion(&quot;1.0.1.4&quot;)]
[assembly: AssemblyFileVersion(&quot;1.0.1.4&quot;)]</pre>
    <p>
        As soon as you have been authenticated open the <em>My First Menu</em> menu and
        click on the <em>Tweets</em> menu item. Enter some text into the TweetBox and click
        the 'Tweet!' button.</p>
    <img alt="Tweets" src="GenesisSCFTwitter/0017.png" complete="true" complete="true" />
    <p>
        You should see your tweet appear in the listbox below. See the highlighted regions
        of the image.</p>
    <img alt="Tweets" src="GenesisSCFTwitter/0018.png" complete="true" complete="true" />
    <p>
        And finally if you sign directly into your Twitter page or any other Twitter client
        you will see your posts appear there as well.</p>
    <img alt="Tweets" src="GenesisSCFTwitter/0019.png" complete="true" complete="true" />
    <p>
        Thats it, you have successfully written a Twitter client on the Genesis Smart Client
        Framework. Each time you update your application, your users will automatically
        get those same updates.</p>
    <h2>
        Other information</h2>
    <p>
        Blue Marble is proud to be a Microsoft BizSpark startup company. <a href="http://www.microsoftstartupzone.com/">
            <img src="http://www.microsoftstartupzone.com/bsdb/images/BizSparkDB_logo.jpg" border="0"
                complete="true" complete="true" />
        </a>
    </p>
</body>
</html>
